/**
 * 蓝牙工具类
 * 提供蓝牙初始化、搜索、连接、数据收发等功能
 */

class BluetoothManager {
  constructor() {
    this.devicesList = []; // 搜索到的蓝牙设备列表
    this.connectedDeviceId = null; // 已连接的设备ID
    this.serviceId = null; // 服务ID
    this.characteristicId = null; // 特征值ID
    this.isBluetoothAvailable = false; // 蓝牙是否可用
    this.isScanning = false; // 是否正在搜索
    this.hasInitialized = false; // 是否已初始化
    this.isInitializing = false; // 是否正在初始化
    this.isConnecting = false; // 是否正在连接
    this.lastError = null; // 最后一次错误信息
    
    // 数据接收回调函数
    this.onDataReceived = null;
    
    // 固定的UUID，不可修改
    // 串口服务UUID
    this.SERVICE_UUID = '6E400001-B5A3-F393-E0A9-E50E24DC4179';
    // 数据发送UUID (写特征值)
    this.SEND_UUID = '6E400002-B5A3-F393-E0A9-E50E24DC4179';
    // 数据接收UUID (通知特征值)
    this.RECEIVE_UUID = '6E400003-B5A3-F393-E0A9-E50E24DC4179';
    
    // 充电桩蓝牙服务的UUID，可以根据实际设备修改
    this.targetServiceUUIDs = [
      // 通用的串口服务UUID (常见于模拟串口的蓝牙设备)
      this.SERVICE_UUID,
    ];

    // 判断运行环境 - 避免使用WeixinJSBridge
    this.runningEnvironment = this._detectEnvironment();
  }

  /**
   * 获取蓝牙初始化状态
   * @returns {boolean} 蓝牙是否已初始化
   */
  get isInitialized() {
    return this.hasInitialized;
  }

  /**
   * 检测当前运行环境
   * @returns {string} 环境类型: 'mp-weixin'|'mp-other'|'app'|'h5'|'unknown'
   * @private
   */
  _detectEnvironment() {
    try {
      // 检测是否在uni-app环境
      if (typeof uni !== 'undefined') {
        // 检测是否在小程序环境
        if (typeof wx !== 'undefined') {
          return 'mp-weixin'; // 微信小程序
        }
        
        // 可以添加其他小程序环境检测
        if (typeof my !== 'undefined') {
          return 'mp-alipay'; // 支付宝小程序
        }
        
        // APP环境
        if (uni.getSystemInfoSync().platform === 'android' || 
            uni.getSystemInfoSync().platform === 'ios') {
          return 'app';
        }
        
        // H5环境
        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
          return 'h5';
        }
      }
      
      return 'unknown';
    } catch (e) {
      console.error('环境检测失败:', e);
      return 'unknown';
    }
  }

  /**
   * 初始化蓝牙
   * @returns {Promise} 返回初始化结果
   */
  initBluetooth() {
    // 如果已经初始化过，直接返回结果
    if (this.hasInitialized) {
      return Promise.resolve({ errMsg: "已初始化蓝牙模块" });
    }
    
    // 如果正在初始化，防止重复调用
    if (this.isInitializing) {
      return new Promise((resolve, reject) => {
        // 每100ms检查一次是否初始化完成，最多等待5秒
        let checkCount = 0;
        const checkInterval = setInterval(() => {
          checkCount++;
          if (this.hasInitialized) {
            clearInterval(checkInterval);
            resolve({ errMsg: "蓝牙模块初始化成功" });
          }
          
          // 5秒超时
          if (checkCount > 50) {
            clearInterval(checkInterval);
            reject(new Error("蓝牙初始化超时"));
          }
        }, 100);
      });
    }
    
    // 标记为正在初始化
    this.isInitializing = true;
    
    return new Promise((resolve, reject) => {
      // 使用try-catch包装整个蓝牙初始化过程
      try {
        // 环境特定的初始化逻辑
        if (this.runningEnvironment === 'mp-weixin') {
          // 微信小程序环境
          this._safeCallApi(
            () => uni.openBluetoothAdapter({
              success: (res) => this._handleInitSuccess(res, resolve),
              fail: (err) => this._handleInitFail(err, reject)
            }),
            (err) => this._handleInitFail(err, reject)
          );
        } else {
          // 其他环境
          uni.openBluetoothAdapter({
            success: (res) => this._handleInitSuccess(res, resolve),
            fail: (err) => this._handleInitFail(err, reject)
          });
        }
      } catch (e) {
        this._handleInitFail(e, reject);
      }
    });
  }

  /**
   * 安全调用API，捕获任何可能的异常
   * @param {Function} apiCall API调用函数
   * @param {Function} errorHandler 错误处理函数
   * @private
   */
  _safeCallApi(apiCall, errorHandler) {
    try {
      apiCall();
    } catch (e) {
      console.error('API调用失败:', e);
      errorHandler(e);
    }
  }

  /**
   * 处理初始化成功
   * @param {Object} res 成功结果
   * @param {Function} resolve Promise解析函数
   * @private
   */
  _handleInitSuccess(res, resolve) {
    console.log('蓝牙初始化成功', res);
    this.isBluetoothAvailable = true;
    this.hasInitialized = true;
    this.isInitializing = false;
    
    // 监听蓝牙状态变化
    this._startBluetoothListener();
    
    resolve(res);
  }

  /**
   * 处理初始化失败
   * @param {Object|Error} err 错误对象
   * @param {Function} reject Promise拒绝函数
   * @private
   */
  _handleInitFail(err, reject) {
    console.error('蓝牙初始化失败', err);
    this.isBluetoothAvailable = false;
    this.hasInitialized = false; // 初始化失败，重置状态
    this.isInitializing = false;
    
    // 在小程序环境中，用户可能没有打开蓝牙
    if (this.runningEnvironment.startsWith('mp-') && 
        err && (err.errCode === 10001 || err.errMsg && err.errMsg.includes('蓝牙未开启'))) {
      uni.showToast({
        title: '请打开蓝牙',
        icon: 'none'
      });
    }
    
    reject(err);
  }

  /**
   * 开始搜索蓝牙设备
   * @returns {Promise} 返回操作结果
   */
  startScan() {
    if (!this.isBluetoothAvailable) {
      return this.initBluetooth()
        .then(() => this._doStartScan())
        .catch(err => Promise.reject(err));
    }
    
    return this._doStartScan();
  }
  
  /**
   * 实际执行蓝牙搜索的方法
   * @returns {Promise} 返回搜索结果
   * @private
   */
  _doStartScan() {
    return new Promise((resolve, reject) => {
      // 清空设备列表
      this.devicesList = [];
      this.isScanning = true;
      
      // 安全调用蓝牙搜索API
      this._safeCallApi(
        () => {
          // 开始搜索
          uni.startBluetoothDevicesDiscovery({
            allowDuplicatesKey: false,
            success: (res) => {
              console.log('开始搜索蓝牙设备', res);
              
              // 监听新设备
              this._setupDeviceFoundListener();
              
              resolve(res);
            },
            fail: (err) => {
              console.error('搜索蓝牙设备失败', err);
              this.isScanning = false;
              reject(err);
            }
          });
        },
        (err) => {
          this.isScanning = false;
          reject(err);
        }
      );
    });
  }
  
  /**
   * 设置蓝牙设备发现监听器
   * @private
   */
  _setupDeviceFoundListener() {
    try {
      // 先移除可能已经存在的监听器，防止重复监听
      uni.offBluetoothDeviceFound();
      
      // 添加新的监听器
      uni.onBluetoothDeviceFound((deviceRes) => {
        try {
          if (!deviceRes || !deviceRes.devices) return;
          
          deviceRes.devices.forEach(device => {
            // 检查设备是否已在列表中
            const idx = this.devicesList.findIndex(item => item.deviceId === device.deviceId);
            if (idx === -1) {
              console.log('发现新设备', device);
              
              // 只将有名称的设备添加到列表（排除不完整的设备信息）
              if (device.name || device.localName) {
                this.devicesList.push(device);
              }
            }
          });
        } catch (e) {
          console.error('处理蓝牙设备信息时出错', e);
        }
      });
    } catch (e) {
      console.error('设置蓝牙发现监听器时出错', e);
    }
  }

  /**
   * 停止蓝牙搜索
   * @returns {Promise} 返回操作结果
   */
  stopScan() {
    return new Promise((resolve, reject) => {
      if (!this.isScanning) {
        return resolve();
      }
      
      this._safeCallApi(
        () => {
          uni.stopBluetoothDevicesDiscovery({
            success: (res) => {
              console.log('停止搜索蓝牙设备', res);
              this.isScanning = false;
              resolve(res);
            },
            fail: (err) => {
              console.error('停止搜索蓝牙设备失败', err);
              reject(err);
            }
          });
        },
        (err) => {
          reject(err);
        }
      );
    });
  }

  /**
   * 连接蓝牙设备
   * @param {String} deviceId 设备ID
   * @returns {Promise} 返回连接结果
   */
  connectDevice(deviceId) {
    if (!deviceId) {
      return Promise.reject(new Error('设备ID不能为空'));
    }
    
    // 防止重复连接
    if (this.isConnecting) {
      return Promise.reject(new Error('正在连接中，请勿重复操作'));
    }
    
    // 记录连接开始，重置错误状态
    this.isConnecting = true;
    this.lastError = null;
    
    // 确保蓝牙已初始化
    const initPromise = this.isBluetoothAvailable ? Promise.resolve() : this.initBluetooth();
    
    return initPromise.then(() => {
      return new Promise((resolve, reject) => {
        // 停止可能正在进行的搜索
        (this.isScanning ? this.stopScan() : Promise.resolve())
          .catch(err => {
            console.warn('停止搜索失败，继续连接', err);
            // 不阻止连接流程继续
          })
          .finally(() => {
            // 确保设备ID格式正确
            const normalizedDeviceId = this.normalizeDeviceId(deviceId);
            console.log(`准备连接设备，原始ID: ${deviceId}, 规范化ID: ${normalizedDeviceId}`);
            
            // 创建连接
            this._safeCallApi(
              () => {
                uni.createBLEConnection({
                  deviceId: normalizedDeviceId,
                  timeout: 15000, // 增加超时时间到15秒
                  success: (res) => {
                    console.log('连接设备成功，准备获取服务', res);
                    this.connectedDeviceId = normalizedDeviceId;
                    
                    // 延迟一小段时间再获取服务，某些设备需要一点时间稳定连接
                    setTimeout(() => {
                      // 连接成功后，获取设备的服务
                      this._getBLEDeviceServices(normalizedDeviceId)
                        .then(serviceInfo => {
                          this.isConnecting = false;
                          resolve(serviceInfo);
                        })
                        .catch(err => {
                          this.isConnecting = false;
                          // 如果获取服务失败，断开连接并拒绝Promise
                          console.error('获取设备服务失败，断开连接', err);
                          
                          // 尝试断开连接，但不管结果如何都拒绝原始Promise
                          uni.closeBLEConnection({
                            deviceId: normalizedDeviceId,
                            complete: () => {
                              this.connectedDeviceId = null;
                              this.serviceId = null;
                              this.characteristicId = null;
                              
                              // 记录详细错误
                              this.lastError = {
                                phase: '获取服务',
                                message: err.errMsg || err.message || '未知错误',
                                code: err.errCode || -1,
                                timestamp: new Date().toISOString()
                              };
                              
                              reject(err);
                            }
                          });
                        });
                    }, 800); // 延迟800ms，给某些设备更多时间准备
                  },
                  fail: (err) => {
                    console.error('连接设备失败', err);
                    this.isConnecting = false;
                    
                    // 记录详细错误
                    this.lastError = {
                      phase: '连接设备',
                      message: err.errMsg || err.message || '未知错误',
                      code: err.errCode || -1,
                      timestamp: new Date().toISOString()
                    };
                    
                    reject(err);
                  }
                });
              },
              (err) => {
                this.isConnecting = false;
                this.lastError = {
                  phase: 'API调用',
                  message: err.message || '未知错误',
                  timestamp: new Date().toISOString()
                };
                reject(err);
              }
            );
          });
      });
    });
  }

  /**
   * 规范化设备ID格式
   * @param {string} deviceId 原始设备ID
   * @returns {string} 规范化后的设备ID
   */
  normalizeDeviceId(deviceId) {
    // 如果为空，直接返回
    if (!deviceId) return deviceId;
    
    // iOS设备通常使用UUID格式，Android使用MAC地址格式
    // UUID格式类似: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
    const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(deviceId);
    
    // 如果是UUID格式，不做处理
    if (isUUID) return deviceId;
    
    // 处理可能的MAC地址格式
    // 移除所有非字母数字字符
    let cleanedId = deviceId.replace(/[^A-Fa-f0-9]/g, '').toUpperCase();
    
    // 如果长度超过12（标准MAC地址长度），截取最后12位
    if (cleanedId.length > 12) {
      console.log(`设备ID过长(${cleanedId.length})，截取为12位`);
      cleanedId = cleanedId.substring(cleanedId.length - 12);
    } 
    // 如果长度不足12位，前面补0
    else if (cleanedId.length < 12) {
      console.log(`设备ID过短(${cleanedId.length})，补齐到12位`);
      cleanedId = cleanedId.padStart(12, '0');
    }
    
    // 有些平台需要冒号分隔的MAC地址
    if (this.runningEnvironment === 'mp-weixin') {
      // 微信小程序环境可能需要冒号分隔的格式
      const pattern = /^([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/;
      const matches = cleanedId.match(pattern);
      
      if (matches) {
        const formattedWithColon = `${matches[1]}:${matches[2]}:${matches[3]}:${matches[4]}:${matches[5]}:${matches[6]}`;
        console.log(`使用冒号分隔格式: ${formattedWithColon}`);
        return formattedWithColon;
      }
    }
    
    console.log(`使用规范化设备ID: ${cleanedId}`);
    return cleanedId;
  }

  /**
   * 断开蓝牙连接
   * @param {String} deviceId 设备ID，不传则断开当前连接
   * @returns {Promise} 返回操作结果
   */
  disconnectDevice(deviceId = null) {
    const targetDeviceId = deviceId || this.connectedDeviceId;
    
    if (!targetDeviceId) {
      return Promise.reject(new Error('未连接设备或未指定设备ID'));
    }
    
    return new Promise((resolve, reject) => {
      uni.closeBLEConnection({
        deviceId: targetDeviceId,
        success: (res) => {
          console.log('断开设备连接成功', res);
          
          // 如果断开的是当前连接的设备，清除连接信息
          if (targetDeviceId === this.connectedDeviceId) {
            this.connectedDeviceId = null;
            this.serviceId = null;
            this.characteristicId = null;
          }
          
          resolve(res);
        },
        fail: (err) => {
          console.error('断开设备连接失败', err);
          reject(err);
        }
      });
    });
  }

  /**
   * 发送数据到蓝牙设备
   * @param {ArrayBuffer} data 要发送的二进制数据
   * @returns {Promise} 返回发送结果
   */
  sendData(data) {
    if (!this.connectedDeviceId) {
      return Promise.reject(new Error('未连接设备'));
    }
    
    if (!this.serviceId) {
      return Promise.reject(new Error('未获取到服务ID'));
    }
    
    if (!this.characteristicId) {
      return Promise.reject(new Error('未获取到特征值ID')); 
    }
    
    
    return new Promise((resolve, reject) => {
      uni.writeBLECharacteristicValue({
        deviceId: this.connectedDeviceId,
        serviceId: this.serviceId,
        characteristicId: this.characteristicId,
        value: data,
        success: (res) => {
          console.log('发送数据成功', res);
          resolve(res);
        },
        fail: (err) => {
          console.error('发送数据失败', err);
          reject(err);
        }
      });
    });
  }

  /**
   * 获取当前蓝牙状态
   * @returns {Promise} 返回蓝牙状态
   */
  getBluetoothAdapterState() {
    return new Promise((resolve, reject) => {
      uni.getBluetoothAdapterState({
        success: (res) => {
          console.log('获取蓝牙状态成功', res);
          this.isBluetoothAvailable = res.available;
          resolve(res);
        },
        fail: (err) => {
          console.error('获取蓝牙状态失败', err);
          reject(err);
        }
      });
    });
  }

  /**
   * 获取已发现的设备列表
   * @returns {Array} 蓝牙设备列表
   */
  getDevicesList() {
    return this.devicesList;
  }

  /**
   * 关闭蓝牙模块
   * @returns {Promise} 返回操作结果
   */
  closeBluetoothAdapter() {
    return new Promise((resolve, reject) => {
      // 先断开可能存在的连接
      if (this.connectedDeviceId) {
        this.disconnectDevice().catch(console.error);
      }
      
      uni.closeBluetoothAdapter({
        success: (res) => {
          console.log('关闭蓝牙模块成功', res);
          this.isBluetoothAvailable = false;
          this.devicesList = [];
          this.connectedDeviceId = null;
          this.serviceId = null;
          this.characteristicId = null;
          this.isScanning = false;
          
          // 移除蓝牙监听器
          this._removeBluetoothListener();
          
          resolve(res);
        },
        fail: (err) => {
          console.error('关闭蓝牙模块失败', err);
          reject(err);
        }
      });
    });
  }

  /**
   * 启动蓝牙状态监听
   * @private
   */
  _startBluetoothListener() {
    try {
      // 先移除可能已经存在的监听器
      this._removeBluetoothListener();
      
      // 监听蓝牙适配器状态变化
      uni.onBluetoothAdapterStateChange((res) => {
        console.log('蓝牙适配器状态变化', res);
        this.isBluetoothAvailable = res.available;
        
        // 如果蓝牙关闭，清理连接状态
        if (!res.available) {
          this.devicesList = [];
          this.connectedDeviceId = null;
          this.serviceId = null;
          this.characteristicId = null;
          this.isScanning = false;
          this.hasInitialized = false;
          
          // 添加蓝牙关闭提示
          uni.showModal({
            title: '蓝牙已关闭',
            content: '您已关闭手机蓝牙，请开启蓝牙后重试',
            showCancel: false,
            success: () => {
              // 可以在这里执行其他操作，如返回到上一页
              console.log('用户确认了蓝牙关闭提示');
            }
          });
        }
      });
      
      // 监听蓝牙连接状态变化
      uni.onBLEConnectionStateChange((res) => {
        console.log('蓝牙连接状态变化', res);
        
        // 如果连接断开，清理连接信息
        if (!res.connected && res.deviceId === this.connectedDeviceId) {
          this.connectedDeviceId = null;
          this.serviceId = null;
          this.characteristicId = null;
        }
      });
    } catch (e) {
      console.error('启动蓝牙监听器失败', e);
    }
  }

  /**
   * 移除蓝牙监听器
   * @private
   */
  _removeBluetoothListener() {
    uni.offBluetoothAdapterStateChange();
    uni.offBLEConnectionStateChange();
    uni.offBluetoothDeviceFound();
    uni.offBLECharacteristicValueChange();
  }

  /**
   * 获取蓝牙设备的服务
   * @param {String} deviceId 设备ID
   * @returns {Promise} 返回设备服务
   * @private
   */
  _getBLEDeviceServices(deviceId) {
    return new Promise((resolve, reject) => {
      uni.getBLEDeviceServices({
        deviceId: deviceId,
        success: (res) => {
          console.log('获取设备服务成功', res);
          
          if (res.services && res.services.length > 0) {
            // 查找指定的服务UUID
            let found = false;
            for (let i = 0; i < res.services.length; i++) {
              if (res.services[i].uuid.toUpperCase() === this.SERVICE_UUID.toUpperCase()) {
                this.serviceId = res.services[i].uuid;
                found = true;
                console.log('找到目标服务UUID:', this.serviceId);
                break;
              }
            }
            
            // 如果没有找到指定服务，使用第一个服务
            if (!found) {
              this.serviceId = res.services[0].uuid;
              console.log('未找到目标服务，使用第一个服务:', this.serviceId);
            }
            
            // 获取该服务的特征值
            this._getBLEDeviceCharacteristics(deviceId, this.serviceId)
              .then(resolve)
              .catch(reject);
          } else {
            const error = new Error('未找到可用的蓝牙服务');
            console.error(error);
            reject(error);
          }
        },
        fail: (err) => {
          console.error('获取设备服务失败', err);
          reject(err);
        }
      });
    });
  }

  /**
   * 获取蓝牙服务的特征值
   * @param {String} deviceId 设备ID
   * @param {String} serviceId 服务ID
   * @returns {Promise} 返回特征值
   * @private
   */
  _getBLEDeviceCharacteristics(deviceId, serviceId) {
    return new Promise((resolve, reject) => {
      uni.getBLEDeviceCharacteristics({
        deviceId: deviceId,
        serviceId: serviceId,
        success: (res) => {
          console.log('获取特征值成功', res);
          
          // 遍历特征值，查找可写的特征值和可通知的特征值
          let writeCharacteristicFound = false;
          let notifyCharacteristicFound = false;
          let writeCharacteristicId = null;
          let notifyCharacteristicId = null;
          
          if (res.characteristics && res.characteristics.length > 0) {
            // 首先尝试寻找指定的发送和接收UUID
            for (let i = 0; i < res.characteristics.length; i++) {
              const item = res.characteristics[i];
              
              // 检查是否是发送UUID
              if (item.uuid.toUpperCase() === this.SEND_UUID.toUpperCase() && item.properties.write) {
                writeCharacteristicId = item.uuid;
                writeCharacteristicFound = true;
                console.log('找到发送特征值:', writeCharacteristicId);
              }
              
              // 检查是否是接收UUID
              if (item.uuid.toUpperCase() === this.RECEIVE_UUID.toUpperCase() && 
                 (item.properties.notify || item.properties.indicate)) {
                notifyCharacteristicId = item.uuid;
                notifyCharacteristicFound = true;
                console.log('找到接收特征值:', notifyCharacteristicId);
              }
            }
            
            // 如果没有找到指定的UUID，则采用老方法
            if (!writeCharacteristicFound || !notifyCharacteristicFound) {
              console.log('未找到指定的特征值，采用特性匹配方式查找');
              
              res.characteristics.forEach(item => {
                // 查找可写的特征值
                if (item.properties.write && !writeCharacteristicFound) {
                  writeCharacteristicId = item.uuid;
                  writeCharacteristicFound = true;
                  console.log('通过特性找到可写特征值:', writeCharacteristicId);
                }
                
                // 查找可通知的特征值
                if ((item.properties.notify || item.properties.indicate) && !notifyCharacteristicFound) {
                  notifyCharacteristicId = item.uuid;
                  notifyCharacteristicFound = true;
                  console.log('通过特性找到可通知特征值:', notifyCharacteristicId);
                }
              });
            }
            
            if (writeCharacteristicFound) {
              this.characteristicId = writeCharacteristicId;
              
              // 如果存在可通知的特征值，则启用通知
              if (notifyCharacteristicFound) {
                this._notifyBLECharacteristicValueChange(deviceId, serviceId, notifyCharacteristicId);
              }
              
              resolve({
                serviceId: serviceId,
                characteristicId: this.characteristicId
              });
            } else {
              const error = new Error('未找到可写的特征值');
              console.error(error);
              reject(error);
            }
          } else {
            const error = new Error('未找到特征值');
            console.error(error);
            reject(error);
          }
        },
        fail: (err) => {
          console.error('获取特征值失败', err);
          reject(err);
        }
      });
    });
  }

  /**
   * 启用特征值变化通知
   * @param {String} deviceId 设备ID
   * @param {String} serviceId 服务ID
   * @param {String} characteristicId 特征值ID
   * @private
   */
  _notifyBLECharacteristicValueChange(deviceId, serviceId, characteristicId) {
    // 先移除可能已存在的特征值变化监听器，避免重复监听
    try {
      uni.offBLECharacteristicValueChange();
    } catch (e) {
      console.warn('移除特征值监听器失败', e);
    }
    
    // 添加新的特征值变化监听器
    uni.onBLECharacteristicValueChange((valueRes) => {
      console.log('收到蓝牙设备数据', valueRes);
      
      // 调用数据接收回调函数，如果已设置
      if (this.onDataReceived && typeof this.onDataReceived === 'function') {
        try {
          this.onDataReceived(valueRes);
        } catch (error) {
          console.error('调用数据接收回调函数时出错:', error);
        }
      }
    });
    
    // 启用通知
    uni.notifyBLECharacteristicValueChange({
      deviceId: deviceId,
      serviceId: serviceId,
      characteristicId: characteristicId,
      state: true,
      success: (res) => {
        console.log('启用特征值通知成功', res);
      },
      fail: (err) => {
        console.error('启用特征值通知失败', err);
      }
    });
  }

  /**
   * 设置数据接收回调函数
   * @param {Function} callback 当收到蓝牙数据时要调用的回调函数，参数为ArrayBuffer
   */
  setOnDataReceivedCallback(callback) {
    if (typeof callback === 'function') {
      this.onDataReceived = callback;
      console.log('成功设置蓝牙数据接收回调');
    } else {
      console.error('回调必须是一个函数');
    }
  }
  
  /**
   * 移除数据接收回调函数
   */
  removeOnDataReceivedCallback() {
    this.onDataReceived = null;
    console.log('已移除蓝牙数据接收回调');
  }
}

// 创建单例实例
const bluetoothManager = new BluetoothManager();

export default bluetoothManager; 